/**
 * 统计数据仓储层
 * 负责项目统计数据的持久化和检索
 */
import cloudHelper from '../helpers/cloud/cloud_helper';
// 使用统一配置入口引用模型
const { StatisticsModel } = require('../../config/models_config');
import SmartCache from '../../helpers/smart_cache';

// 创建统计缓存实例
const statisticsCache = new SmartCache('statistics', 10 * 60 * 1000); // 10分钟缓存

class StatisticsRepository {
  /**
   * 获取项目统计数据
   * @param {String} projectId 项目ID
   * @param {Object} params 查询参数
   */
  async getProjectStatistics(projectId, params = {}) {
    if (!projectId) throw new Error('项目ID不能为空');
    
    const cacheKey = `project:${projectId}:${JSON.stringify(params)}`;
    
    try {
      // 尝试从缓存获取
      return await statisticsCache.get(cacheKey, async () => {
        // 从云函数获取数据
        const result = await cloudHelper.callCloudData('statistics/project', {
          projectId,
          ...params
        });
        
        // 转换为领域模型
        return result ? new StatisticsModel(result) : null;
      });
    } catch (err) {
      console.error('[StatisticsRepository] getProjectStatistics 错误:', err);
      throw err;
    }
  }
  
  /**
   * 获取项目进度统计
   * @param {String} projectId 项目ID
   * @param {Object} params 查询参数
   */
  async getProjectProgress(projectId, params = {}) {
    if (!projectId) throw new Error('项目ID不能为空');
    
    const cacheKey = `progress:${projectId}:${JSON.stringify(params)}`;
    
    try {
      // 尝试从缓存获取
      return await statisticsCache.get(cacheKey, async () => {
        // 从云函数获取数据
        const result = await cloudHelper.callCloudData('statistics/progress', {
          projectId,
          ...params
        });
        
        // 转换为领域模型
        return result ? new StatisticsModel({
          projectId,
          ...params,
          progress: result
        }) : null;
      });
    } catch (err) {
      console.error('[StatisticsRepository] getProjectProgress 错误:', err);
      throw err;
    }
  }
  
  /**
   * 获取项目任务统计
   * @param {String} projectId 项目ID
   * @param {Object} params 查询参数
   */
  async getProjectTasks(projectId, params = {}) {
    if (!projectId) throw new Error('项目ID不能为空');
    
    const cacheKey = `tasks:${projectId}:${JSON.stringify(params)}`;
    
    try {
      // 尝试从缓存获取
      return await statisticsCache.get(cacheKey, async () => {
        // 从云函数获取数据
        const result = await cloudHelper.callCloudData('statistics/tasks', {
          projectId,
          ...params
        });
        
        // 转换为领域模型
        return result ? new StatisticsModel({
          projectId,
          ...params,
          tasks: result
        }) : null;
      });
    } catch (err) {
      console.error('[StatisticsRepository] getProjectTasks 错误:', err);
      throw err;
    }
  }
  
  /**
   * 获取项目资源使用统计
   * @param {String} projectId 项目ID
   * @param {Object} params 查询参数
   */
  async getProjectResources(projectId, params = {}) {
    if (!projectId) throw new Error('项目ID不能为空');
    
    const cacheKey = `resources:${projectId}:${JSON.stringify(params)}`;
    
    try {
      // 尝试从缓存获取
      return await statisticsCache.get(cacheKey, async () => {
        // 从云函数获取数据
        const result = await cloudHelper.callCloudData('statistics/resources', {
          projectId,
          ...params
        });
        
        // 转换为领域模型
        return result ? new StatisticsModel({
          projectId,
          ...params,
          resources: result
        }) : null;
      });
    } catch (err) {
      console.error('[StatisticsRepository] getProjectResources 错误:', err);
      throw err;
    }
  }
  
  /**
   * 获取项目风险统计
   * @param {String} projectId 项目ID
   * @param {Object} params 查询参数
   */
  async getProjectRisks(projectId, params = {}) {
    if (!projectId) throw new Error('项目ID不能为空');
    
    const cacheKey = `risks:${projectId}:${JSON.stringify(params)}`;
    
    try {
      // 尝试从缓存获取
      return await statisticsCache.get(cacheKey, async () => {
        // 从云函数获取数据
        const result = await cloudHelper.callCloudData('statistics/risks', {
          projectId,
          ...params
        });
        
        // 转换为领域模型
        return result ? new StatisticsModel({
          projectId,
          ...params,
          risks: result
        }) : null;
      });
    } catch (err) {
      console.error('[StatisticsRepository] getProjectRisks 错误:', err);
      throw err;
    }
  }
  
  /**
   * 生成项目周期报告
   * @param {String} projectId 项目ID
   * @param {Object} params 生成参数
   */
  async generateProjectReport(projectId, params = {}) {
    if (!projectId) throw new Error('项目ID不能为空');
    
    try {
      // 调用云函数
      const result = await cloudHelper.callCloudSumbit('statistics/generate', {
        projectId,
        ...params
      });
      
      // 清除相关缓存
      statisticsCache.removeByPattern(`^project:${projectId}:`);
      statisticsCache.removeByPattern(`^progress:${projectId}:`);
      statisticsCache.removeByPattern(`^tasks:${projectId}:`);
      statisticsCache.removeByPattern(`^resources:${projectId}:`);
      statisticsCache.removeByPattern(`^risks:${projectId}:`);
      
      return result;
    } catch (err) {
      console.error('[StatisticsRepository] generateProjectReport 错误:', err);
      throw err;
    }
  }
  
  /**
   * 获取多项目统计数据（数据看板）
   * @param {Array} projectIds 项目ID数组
   * @param {Object} params 查询参数
   */
  async getMultiProjectStatistics(projectIds, params = {}) {
    if (!projectIds || !Array.isArray(projectIds) || projectIds.length === 0) {
      throw new Error('项目ID数组不能为空');
    }
    
    const cacheKey = `dashboard:${projectIds.join(',')}:${JSON.stringify(params)}`;
    
    try {
      // 尝试从缓存获取
      return await statisticsCache.get(cacheKey, async () => {
        // 从云函数获取数据
        const result = await cloudHelper.callCloudData('statistics/dashboard', {
          projectIds,
          ...params
        });
        
        // 转换为领域模型数组
        if (result && Array.isArray(result)) {
          return result.map(item => new StatisticsModel(item));
        }
        
        return [];
      });
    } catch (err) {
      console.error('[StatisticsRepository] getMultiProjectStatistics 错误:', err);
      throw err;
    }
  }
}

export default new StatisticsRepository(); 